package cn.itcast.up.web33.up_web33.service.impl;

import cn.itcast.up.web33.up_web33.bean.dto.ModelDto;
import cn.itcast.up.web33.up_web33.bean.dto.TagDto;
import cn.itcast.up.web33.up_web33.bean.dto.TagModel;
import cn.itcast.up.web33.up_web33.bean.po.ModelPo;
import cn.itcast.up.web33.up_web33.bean.po.TagPo;
import cn.itcast.up.web33.up_web33.repo.ModelRepo;
import cn.itcast.up.web33.up_web33.repo.TagRepo;
import cn.itcast.up.web33.up_web33.service.TagService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class TagServiceImpl implements TagService {

    @Autowired
    private TagRepo tagRepo;
    @Autowired
    private ModelRepo modelRepo;

    @Override
    public void saveTags(List<TagDto> list) {
        //取出123级标签,存入MySQL
        //转换,将dto->po
        //方案一:
//        for (TagDto tagDto : list) {
//            TagPo tagPo = convert(tagDto);
//            //查看当前的级别,开始向数据库存储.
//            TagPo save = tagRepo.save(tagPo);
//        }
        //方案二:
//        List<TagPo> poList = list.stream().map((x) -> {
//            return convert(x);
//        }).collect(Collectors.toList());
        //方案三:
        List<TagPo> poList = list.stream().map(this::convert).collect(Collectors.toList());
        //将数据存入MySQL
        //需要先设置父级ID.
        TagPo po1 = poList.get(0);
        TagPo po2 = poList.get(1);
        TagPo po3 = poList.get(2);
        //临时变量
        TagPo tempPo = null;
        /*电商
            京东
                    人口属性
        银行
            北京银行
                    人口属性 */
        //先保存1级
            //先看有没有1级的.
        tempPo = tagRepo.findByPidAndName(po1.getPid(), po1.getName());
        //如果tempPo == null,那么 就保存,否则直接拿来用
        if (tempPo == null){
            //将保存结果给临时变量
            tempPo = tagRepo.save(po1);
        }
        //保存2级
//        保存之前先检查有没有数据
        po2.setPid(tempPo.getId());
        tempPo = tagRepo.findByPidAndName(po2.getPid(), po2.getName());
        //如果tempPo == null,那么 就保存,否则直接拿来用
        if (tempPo == null){
            //将保存结果给临时变量
            tempPo = tagRepo.save(po2);
        }

        //保存3级.
        po3.setPid(tempPo.getId());
        tempPo = tagRepo.findByPidAndName(po3.getPid(), po3.getName());
        //如果tempPo == null,那么 就保存,否则直接拿来用
        if (tempPo == null){
            //将保存结果给临时变量
            tempPo = tagRepo.save(po3);
        }
    }

    @Override
    public List<TagDto> findByPid(Long pid) {

        List<TagPo> poList = tagRepo.findByPid(pid);
        return poList.stream().map(this::convert).collect(Collectors.toList());
    }

    @Override
    public List<TagDto> findByLevel(Integer level) {
        return tagRepo.findByLevel(level).stream().map(this::convert).collect(Collectors.toList());
    }

    @Override
    public void saveTagModel(TagDto tag, ModelDto model) {
        //1. 先保存4级标签
        TagPo tagPo = tagRepo.save(convert(tag));
        //2. 根据4级标签的ID插入模型
        modelRepo.save(convert(model, tagPo.getId()));
    }

    @Override
    public List<TagModel> findAllTagModel(Long pid) {
        ArrayList<TagModel> list = new ArrayList<>();
        //根据3级ID查询4级列表
        List<TagPo> tagList = tagRepo.findByPid(pid);
        for (TagPo tagPo : tagList) {
            //根据4级ID查询对应的模型
            Long tagid = tagPo.getId();
            ModelPo modelPo = modelRepo.findByTagId(tagid);
            //将模型和标签合并为TagModel对象
            list.add(new TagModel(convert(tagPo), convert(modelPo)));
        }
        return list;
    }

    private ModelDto convert(ModelPo modelPo) {
        ModelDto modelDto = new ModelDto();
        modelDto.setId(modelPo.getId());
        modelDto.setName(modelPo.getName());
        modelDto.setMainClass(modelPo.getMainClass());
        modelDto.setPath(modelPo.getPath());
        modelDto.setArgs(modelPo.getArgs());
        modelDto.setState(modelPo.getState());
        modelDto.setSchedule(modelDto.parseDate(modelPo.getSchedule()));
        return modelDto;
    }


    //modelDto => ModelPo
    private ModelPo convert(ModelDto modelDto, Long id) {
        ModelPo modelPo = new ModelPo();
        modelPo.setId(modelDto.getId());
        //设置4级ID为外部传入的ID
        modelPo.setTagId(id);
        modelPo.setName(modelDto.getName());
        modelPo.setMainClass(modelDto.getMainClass());
        modelPo.setPath(modelDto.getPath());
        modelPo.setSchedule(modelDto.getSchedule().toPattern());
        modelPo.setCtime(new Date());
        modelPo.setUtime(new Date());
        modelPo.setState(modelDto.getState());
        modelPo.setArgs(modelDto.getArgs());
        return modelPo;
    }



    private TagDto convert(TagPo po){
        TagDto tagDto = new TagDto();
        tagDto.setId(po.getId());
        tagDto.setLevel(po.getLevel());
        tagDto.setName(po.getName());
        tagDto.setPid(po.getPid());
        tagDto.setRule(po.getRule());
        return tagDto;
    }




    /**
     * 负责将tagDto转换为TagPo对象
     * @param dto
     * @return
     */
    private TagPo convert(TagDto dto){
        TagPo tagPo = new TagPo();
        tagPo.setId(dto.getId());
        //判断当前dto的等级,如果是1级,那么直接给个pID=-1就行了
        if (dto.getLevel()!= null && dto.getLevel() == 1){
            tagPo.setPid(-1L);
        }else {
            tagPo.setPid(dto.getPid());
        }
        tagPo.setName(dto.getName());
        tagPo.setRule(dto.getRule());
        tagPo.setLevel(dto.getLevel());
        return tagPo;
    }
}
